#include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<string>
#include<typeinfo>
#include<unordered_map>
#include<map>
#include<utility>
#include<memory>
using namespace std;

//void addNode(int val,ListNode *l) ;
// void sort_func(vector<string> &words)   //按字典序排序并且删除重复单词
// {
//     sort(words.begin(),words.end());
//     //auto  temp = unique(words.begin(),words.end());
//     //words.erase(temp,words.end());
// }
// bool sortPrinciple(string &a,string &b)     //不改变单词的相对顺序
// {
//    return a.size() > b.size();
    
// }

// bool partition_Principle(string &a)
// {
//     return a.size() >= 5;
// }

// bool print_BeyongFIve(vector<string> &words)   //打印长度超过6的单词
// {
//     sort_func(words);
//     auto p = partition(words.begin(),words.end(),partition_Principle);
//     for(auto temp = words.begin(); temp < p;temp++)
//     {
//         cout << *temp << endl;
//     }
// }

// bool beyondSix(string &a)
// {
//     return a.size() > 6;
// }

// int count_beyondSix(vector<string> &words)  //计数单词长度超过6的
// {
//     int res = count_if(words.begin(),words.end(),beyondSix);  
//     return res;
// }

// vector<int> func(int key,unordered_map<int,int> mp);


// vector<int> twoSum(vector<int>& nums, int target) {
//         multimap<int,int> mp;
//         for(int i = 0;i < nums.size();i++)
//         {
//             mp.insert(pair<int,int>(nums[i],i));
//         }
//         sort(nums.begin(),nums.end());
//         vector<int> v;
//         int left = 0,right = nums.size() - 1;
//         while(left < right)
//         {
//             int res = nums[left] + nums[right];
//             if(res == target)
//             {
//                 if(nums[left] == nums[right])
//                 {
//                     v = func(nums[left],mp);
//                 }
//                 else
//                 {
//                 v.push_back(mp[nums[left]]);
//                 v.push_back(mp[nums[right]]);
//                 }
//                 return v;
//             }
//             if(res > target)
//             right--;
//             else
//             left++;
//         }
//         return v;
//     }
//     vector<int> func(int key,multimap<int,int> mp)
//     {
//         auto ite = mp.begin();
//         vector<int> v;
//         while(ite != mp.end())
//         {
            
//             if(key == ite->first)
//             {
//                 v.push_back(ite->second);
//             }
//             ite++;
//         }
//         return v;
//     }

  struct ListNode {
      int val;
      ListNode *next;
      ListNode() : val(0), next(nullptr) {}
      ListNode(int x) : val(x), next(nullptr) {}
      ListNode(int x, ListNode *next) : val(x), next(next) {}
  };
    void addNode(int val,ListNode *l)   //
    {
        ListNode *temp = (ListNode *)malloc(sizeof(ListNode));//在结果链表上添加节点
        temp->val = val;
        temp->next = NULL;
        ListNode *p = l;
        while(p && p->next)
        p = p->next;
        if(p)
        p->next = temp;
    }
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode *p = l1,*q = l2,*res = nullptr;
        int key = 0;    //该值保存和的进位的值
        // if(p->val == 0)    //如果p或者q任意一个为零，直接返回另一个链表
        // return q;
        // if(q->val == 0)    //
        // return p;     
        cout << l1->val;
        cout <<"ok";      
        // while(p && q)      //只要p且q不为空，就一直从低位相加，并且保存仅为一直加到
        // {                   //任意一条链表为空
        //     int temp = p->val + q->val + key;
        //     addNode(temp%10,res);
        //     key = key / 10;
        //     p = p->next;
        //     q = q->next;
        // }
        cout << "ok";
        // if(!q)
        // q = p;
        // while(q)
        // {
        //     addNode((q->val + key) % 10,res);
        //     key = key /10;
        //     p = p->next;
        // }
        return res;
    }

void createLinklist(ListNode *l,vector<int> v)    //尾插法建立链表
{
    ListNode *p = l;
    for(int i = 0;i < v.size();i++)
    {
    ListNode *temp = (ListNode *)malloc(sizeof(ListNode));  //申请节点空间
    temp->val = v[i];
    temp->next = NULL;
    if(p)
    {
        while (p->next)
        {
            /* code */
            p = p->next;
        }
        p->next = temp;
        cout << "not head" << endl;
        cout << p->val << endl;
    }
    else
    {
        l = temp;
        cout << "head is ok" << endl;
        cout << l->val << endl ;
    }
    }
}

/****************************************************/
/****************************************************/
/*用函数传递动态申请的数组，并且在main函数中释放申请的内存
/****************************************************/
/****************************************************/
/****************************************************/
// vector<int> *func()
// {
//     return new vector<int>;
// }
// vector<int> *getIn()
// {
//     vector<int> *temp = func();
//     int get;
//     while (cin >> get)
//     {
//         temp->push_back(get);
//     }
//     return temp;
// }
// vector<int> *getOut()
// {
//     vector<int> *temp= getIn();
//     //vector<int>::iterator res = (*temp).begin();
//     for(int res:(*temp))
//     {
//         cout << "this is output " << res << endl;
//     }
//     return temp;
// }
/****************************************************/
/****************************************************/
/****************************************************/
/*用shared_ptr实现上面的功能的同等实现
/****************************************************/
/****************************************************/



shared_ptr<vector<int>> func()
{
    return make_shared<vector<int>>();
}
shared_ptr<vector<int>> getIn()
{
     auto temp = func();
    int get;
    while (cin >> get)
    {
        temp->push_back(get);
    }
    return temp;
}
shared_ptr<vector<int>> getOut()
{
    shared_ptr<vector<int>> temp= getIn();
    //vector<int>::iterator res = (*temp).begin();
    for(int res:(*temp))
    {
        cout << "this is output " << res << endl;
    }
    return temp;
}
int main()
{
//     cout << "hello world" << endl;
//     vector<string> v = {"sidfk","sdf","sd","gfkgfgfj","gfdgdfgdf","sdf","sidfk"};
//     print_BeyongFIve(v);
//    int res = count_beyondSix(v);
//    cout << res << endl;
//    system("pause");

    // int temp;   
    // cin >> temp;
    // auto f = [temp]()mutable->bool
    // {

    // } 
    // sort(v.begin(),v.end(),sortPrinciple);   //**测试unique函数的用法
    // auto temp = unique(v.begin(),v.end());
    // cout << *temp << endl;
    // cout <<"word" <<endl ;                   //**//



    // vector<int> list{1,4,3,5,9,2,4};
    // unordered_map<int, int> map;  
    //    for (int i=0; i<list.size(); i++){  
    //        map[i] = list[i];  
    //    }  
    //    cout << map[0] << endl;  
    //    for (unordered_map<int, int>::iterator i = map.begin(); i != map.end(); i++){  
    //        cout << i->first << ' ' << i->second << endl;  
    //    }  
    //    if (map.find(3) != map.end()) {  
    //        cout << "find key=" << map.find(3)->first << ", value=" << map.find(3)->second << endl;  
    //    }  
    //    if (map.count(5) > 0) {  
    //        cout << "find 5: " << map.count(5) << endl;  
    //    }            
    //    cout << "hello";        



    // ListNode *p = NULL,*q = NULL;
    // vector<int> a{2,4,3};
    // vector<int> b{5,6,4};
    // createLinklist(p,a);
    // ListNode *temp = p;
    // while (temp)
    // {
    //     cout << temp->val << endl;
    // }
    
    // for(auto temp :b)
    // {
    //     createLinklist(temp,q);
    // }
    
    
    //addTwoNumbers(p,q);
    // cout << "test";

    // string s{"asdf,gdfg,cbcvb,asd"};
    // vector<string> str = {"dsdas","dds","asd","gdfgfd","wery"};
    // for(auto begin = str.crbegin(),end = str.crend();begin != end; begin++)
    // {
    //     cout << *begin << endl;
       
        
    // }
    //  cout << "---------" << endl;
    // for(auto begin = s.crbegin(),end = s.crend(); begin != end ; begin++)
    // {
    //     cout << *begin << endl;
    // }

    // vector<pair<string,int>> v;
    // v.push_back(make_pair("fsd",1));   
    //v.push_back(pair<string,int>("sdf",1));
    // cout << v[0].second << endl;

    // vector<int> v = {1,2,3};
    // map<string,vector<int>> mp{{"asd",v},{"qwe",{4,5,6}}};
    // map<string,vector<int>>::iterator res = mp.find("qwe");
    // cout<< res->second.size() << endl;
    // cout << res->second[0] << endl << res->second[1] << endl;


    // multimap<string,string> mulMp{{"bifeiyu","tuina"},{"bifeiyu","tuinatwo"},{"buzhiming","pingfandeshijie"}};
    // multimap<string,string>::iterator temp;
    // int count = 0;
    // while (mulMp.find("bifeiyu") != mulMp.end() )
    // {
    //     count++;
    //     temp = mulMp.find("bifeiyu");
    //     mulMp.erase(temp);
    // }
    // cout << mulMp.size() << endl;
    // cout << count << endl;

    vector<int> * temp = getOut();
    delete temp;
     cout << "memory free success" << endl;
    return 1;
}


class strBlob
{
    public:
    typedef vector<string>::size_type size_type;
    strBlob();
    strBlob(initializer_list<string> i1);
    size_type size()const{return data->size();}
    bool empty()const{return data->empty();}
    void push_back(const string &s){data->push_back(s);}


    private:
    shared_ptr<vector<string>> data;
};
strBlob::strBlob():data(make_shared<vector<string>>()){}

strBlob::strBlob(initializer_list<string> i1):data(make_shared<vector<string>>(i1)){}